/*
     File: AtomicElementView.m
 Abstract: Displays the Atomic Element information in a large format tile.
  Version: 1.8 
 Copyright (C) 2009 Apple Inc. All Rights Reserved.
 
 */

#import "AtomicElementView.h"
#import "AtomicElementViewController.h"
#import "Train.h"
#import <QuartzCore/QuartzCore.h>


@implementation AtomicElementView
@synthesize element;
@synthesize viewController;
@synthesize dataBaseName;

// the preferred size of this view is the size of the background image
+ (CGSize)preferredViewSize {
	return CGSizeMake(256,256);
}


// initialize the view, calling super and setting the 
// properties to nil
- (id)initWithFrame:(CGRect)frame {
    if (self = [super initWithFrame:frame]) {
        // Initialization code here.
		element = nil;
		viewController = nil;
		// set the background color of the view to clearn
		self.backgroundColor=[UIColor clearColor];
		
    }
    return self;
}

// yes this view can become first responder
- (BOOL)canBecomeFirstResponder {
	return YES;
}

// when a touch event occurs tell the view controller to flip this view to the 
// back and show the AtomicElementFlippedView instead.
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {	
	[viewController flipCurrentView];
}

-(double) findMatchSize:(NSString*) ForString withStartSize:(double)fStartSZ AndBounds:(CGRect)bounds
{
    double fStartSize=fStartSZ;
    CGSize stringSize;
    UIFont* font;
    do{
	//find out, what the font's size should be:
	fStartSize-=.5f;
	font = [UIFont boldSystemFontOfSize: fStartSize];
	stringSize = [ForString sizeWithFont:font];
    }
    while(stringSize.width>=bounds.size.width);

    return fStartSize;
}

- (void)drawRect:(CGRect)rect {
	
	// get the background image for the state of the element
	// position it appropriately and draw the image
	UIImage *backgroundImage = [element stateImageForAtomicElementView];	
	CGRect elementSymbolRectangle = CGRectMake(0,0, [backgroundImage size].width, [backgroundImage size].height);
	[backgroundImage drawInRect:elementSymbolRectangle];
	
	// all the text is drawn in white
	[[UIColor whiteColor] set];
	
	// draw the element name
	UIFont *font;
	CGSize stringSize;
	double fStartSize=25.5f;
	fStartSize=[self findMatchSize: element.startStation withStartSize: fStartSize AndBounds: elementSymbolRectangle];
	font = [UIFont boldSystemFontOfSize: fStartSize];
	stringSize = [element.startStation sizeWithFont:font];
	//printf("Found size is: %.2f\n", fStartSize);
	CGPoint point = CGPointMake((self.bounds.size.width-stringSize.width)/2,256/2-80);
	[element.startStation drawAtPoint:point withFont:font];

	// draw the destination station:
	fStartSize = [self findMatchSize: element.endStation withStartSize: 35.5f AndBounds: elementSymbolRectangle];
	font = [UIFont boldSystemFontOfSize: fStartSize];
	stringSize = [element.endStation sizeWithFont:font];
    	point = CGPointMake((self.bounds.size.width-stringSize.width)/2,256/2-50);
	[element.endStation drawAtPoint:point withFont:font];

	// draw the element symbol	
	font = [UIFont boldSystemFontOfSize:96];
	stringSize = [element.sTime sizeWithFont:font];
	point = CGPointMake((self.bounds.size.width-stringSize.width)/2,256-120);
	[element.sTime drawAtPoint:point withFont:font];
}


- (void)dealloc {
	// the view controller is an assign, so just set it to nil
	viewController = nil;
	
	//[element release];
	[super dealloc];
}

CGImageRef AEViewCreateGradientImage (int pixelsWide,
	int pixelsHigh)
{
    CGImageRef theCGImage = NULL;
    CGContextRef gradientBitmapContext = NULL;
    CGColorSpaceRef colorSpace;
    CGGradientRef grayScaleGradient;
    CGPoint gradientStartPoint, gradientEndPoint;

    // Our gradient is always black-white and the mask
    // must be in the gray colorspace
    colorSpace = CGColorSpaceCreateDeviceGray();

    // create the bitmap context
    gradientBitmapContext = CGBitmapContextCreate (NULL, pixelsWide, pixelsHigh,
	    8, 0, colorSpace, kCGImageAlphaNone);

    if (gradientBitmapContext != NULL) {
	// define the start and end grayscale values (with the alpha, even though
	// our bitmap context doesn't support alpha the gradient requires it)
	CGFloat colors[] = {0.0, 1.0,1.0, 1.0,};

	// create the CGGradient and then release the gray color space
	grayScaleGradient = CGGradientCreateWithColorComponents(colorSpace, colors, NULL, 2);

	// create the start and end points for the gradient vector (straight down)
	gradientStartPoint = CGPointZero;
	gradientEndPoint = CGPointMake(0,pixelsHigh);

	// draw the gradient into the gray bitmap context
	CGContextDrawLinearGradient (gradientBitmapContext, grayScaleGradient, gradientStartPoint, gradientEndPoint, kCGGradientDrawsAfterEndLocation);

	// clean up the gradient
	CGGradientRelease(grayScaleGradient);

	// convert the context into a CGImageRef and release the
	// context
	theCGImage=CGBitmapContextCreateImage(gradientBitmapContext);
	CGContextRelease(gradientBitmapContext);	
    }

    // clean up the colorspace
    CGColorSpaceRelease(colorSpace);

    // return the imageref containing the gradient
    return theCGImage;
}


- (UIImage *)reflectedImageRepresentationWithHeight:(NSUInteger)height
{
	CGContextRef mainViewContentContext;
    CGColorSpaceRef colorSpace;
	
    colorSpace = CGColorSpaceCreateDeviceRGB();
	
	// create a bitmap graphics context the size of the image
    mainViewContentContext = CGBitmapContextCreate (NULL, self.bounds.size.width,height, 8,0, colorSpace, kCGImageAlphaPremultipliedLast);
	
	// free the rgb colorspace
    CGColorSpaceRelease(colorSpace);	
	
	if (mainViewContentContext==NULL)
		return NULL;
	
	// offset the context. This is necessary because, by default, the  layer created by a view for
	// caching its content is flipped. But when you actually access the layer content and have
	// it rendered it is inverted. Since we're only creating a context the size of our 
	// reflection view (a fraction of the size of the main view) we have to translate the context the
	// delta in size, render it, and then translate back (we could have saved/restored the graphics 
	// state
	
	CGFloat translateVertical=self.bounds.size.height-height;
	CGContextTranslateCTM(mainViewContentContext,0,-translateVertical);
	
	// render the layer into the bitmap context
	[self.layer renderInContext:mainViewContentContext];
	
	// translate the context back
	CGContextTranslateCTM(mainViewContentContext,0,translateVertical);
	
	// Create CGImageRef of the main view bitmap content, and then
	// release that bitmap context
	CGImageRef mainViewContentBitmapContext=CGBitmapContextCreateImage(mainViewContentContext);
	CGContextRelease(mainViewContentContext);
	
	// create a 2 bit CGImage containing a gradient that will be used for masking the 
	// main view content to create the 'fade' of the reflection.  The CGImageCreateWithMask
	// function will stretch the bitmap image as required, so we can create a 1 pixel wide
	// gradient
	CGImageRef gradientMaskImage=AEViewCreateGradientImage(1,height);
	
	// Create an image by masking the bitmap of the mainView content with the gradient view
	// then release the  pre-masked content bitmap and the gradient bitmap
	CGImageRef reflectionImage=CGImageCreateWithMask(mainViewContentBitmapContext,gradientMaskImage);
	CGImageRelease(mainViewContentBitmapContext);
	CGImageRelease(gradientMaskImage);
	
	// convert the finished reflection image to a UIImage 
	UIImage *theImage=[UIImage imageWithCGImage:reflectionImage];
	
	// image is retained by the property setting above, so we can 
	// release the original
	CGImageRelease(reflectionImage);
	
	// return the image
	return theImage;
}



@end
